/**
 * 工具函数模块
 * 提供数据处理、路径解析等通用功能
 */

/**
 * 格式化显示值
 * 根据 schema 定义将数据转换为适合显示的格式
 *
 * @param {Object} schema Schema 定义
 * @param {*} data 原始数据
 * @returns {string} 格式化后的显示值
 */
export function formatDisplayValue(schema, data) {
  if (schema.thin?.type === "select") {
    // 对于 select，显示选项的 label
    const options = schema.thin.options || [];
    const option = options.find(
      (opt) => (typeof opt === "object" ? opt.value : opt) === data
    );
    return option
      ? typeof option === "object"
        ? option.label || option.value
        : option
      : data || "";
  } else if (schema.type === "boolean") {
    // 对于布尔值，显示是/否
    return data ? "是" : "否";
  } else {
    // 其他类型直接显示值
    return data || "";
  }
}

/**
 * 查找包含 thin_data 的最近容器元素
 *
 * @param {HTMLElement} element 起始元素
 * @returns {HTMLElement|null} 找到的容器元素或 null
 */
export function findDataContainer(element) {
  let current = element;
  while (current && !current.hasOwnProperty("thin_data")) {
    current = current.parentElement;
  }
  return current;
}

/**
 * 解析路径并获取目标对象
 * 支持数组索引的路径解析，如 "a.b[0].c" 或 "a/b[0]/c"
 *
 * @param {HTMLElement} container 容器元素
 * @param {string} path 数据路径
 * @returns {Object|null} 包含目标对象和最终键名的对象，或 null
 */
export function getTargetAndPath(container, path) {
  const current = findDataContainer(container);
  if (!current?.thin_data) return null;

  // 统一路径分隔符为 "."
  const normalizedPath = path.replace(/\//g, ".");
  const pathParts = normalizedPath.split(".");

  let target = current.thin_data;
  let finalKey = pathParts[pathParts.length - 1];

  // 处理除最后一部分外的所有路径部分
  for (let i = 0; i < pathParts.length - 1; i++) {
    const pathPart = pathParts[i];
    const arrayMatch = pathPart.match(/\[(\d+)\]/);

    if (arrayMatch) {
      const arrayName = pathPart.split("[")[0];
      const index = parseInt(arrayMatch[1]);

      if (!target[arrayName]) {
        target[arrayName] = [];
      }
      if (!target[arrayName][index]) {
        target[arrayName][index] = {};
      }
      target = target[arrayName][index];
    } else {
      if (!target[pathPart]) {
        target[pathPart] = {};
      }
      target = target[pathPart];
    }
  }

  // 处理最后一个键是否包含数组索引
  const finalArrayMatch = finalKey.match(/\[(\d+)\]/);
  if (finalArrayMatch) {
    const arrayName = finalKey.split("[")[0];
    const index = parseInt(finalArrayMatch[1]);
    if (!target[arrayName]) {
      target[arrayName] = [];
    }
    target = target[arrayName];
    finalKey = index;
  }

  return { target, finalKey };
}

/**
 * 创建数据更新函数
 *
 * @param {HTMLElement} container 容器元素
 * @param {string} path 数据路径
 * @returns {Function} 更新函数
 */
export function createUpdateDataFunction(container, path) {
  return (value) => {
    const result = getTargetAndPath(container, path);
    if (result) {
      result.target[result.finalKey] = value;

      // 触发数据更新事件
      const dataContainer = findDataContainer(container);
      if (dataContainer) {
        const event = new CustomEvent("thin_data_change", {
          detail: {
            path: path,
            value: value,
            data: dataContainer.thin_data,
          },
          bubbles: true,
        });
        dataContainer.dispatchEvent(event);
      }
    }
  };
}
